/**
 * 数据持久化服务
 * 负责智能体数据的服务器端存储和管理
 */

import { apiClient } from '../api/client'
import type { Agent, AgentData, CreateAgentInput, AgentOperationResult, ApiResponse, BackupInfo } from '../types/agent'

/**
 * 生成唯一ID
 * @returns 返回基于时间戳和随机数的唯一标识符
 */
function generateId(): string {
  return `agent_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
}

/**
 * 获取当前时间的ISO字符串
 * @returns 返回格式化的时间字符串
 */
function getCurrentTime(): string {
  return new Date().toISOString()
}

/**
 * 从服务器获取智能体数据
 * @returns 返回智能体数据数组的Promise
 */
export async function loadAgents(): Promise<Agent[]> {
  try {
    const response = await apiClient.get<ApiResponse<{items: Agent[], total: number, page: number, limit: number, totalPages: number}>>('/agents')
    if (response.data.success && response.data.data && response.data.data.items) {
      return response.data.data.items
    }
    console.error('获取智能体数据失败:', response.data.error)
    return []
  } catch (error) {
    console.error('读取智能体数据失败:', error)
    return []
  }
}

/**
 * 添加新的智能体
 * @param input 智能体创建参数
 * @returns 返回创建的智能体数据和操作结果的Promise
 */
export async function addAgent(input: CreateAgentInput): Promise<AgentOperationResult> {
  try {
    console.log('🔧 [dataService] 开始处理addAgent请求')
    console.log('🔧 [dataService] 接收到的输入数据:', JSON.stringify(input, null, 2))
    
    // 客户端基础验证
    if (!input.name?.trim()) {
      throw new Error('智能体名称不能为空')
    }
    if (!input.author?.trim()) {
      throw new Error('作者不能为空')
    }
    if (!input.shareUrl?.trim()) {
      throw new Error('分享链接不能为空')
    }

    console.log('✅ [dataService] 客户端基础验证通过')

    // 构造请求数据
    const agentData = {
      name: input.name.trim(),
      description: input.description?.trim() || '',
      author: input.author.trim(),
      version: input.version?.trim() || '1.0.0',
      category: input.category || 'general',
      shareUrl: input.shareUrl.trim(),
      tags: input.tags || [],
      usage: input.usage?.trim() || '',
      config: input.config || {}
    }

    console.log('📦 [dataService] 构造的请求数据:', JSON.stringify(agentData, null, 2))
    console.log('📦 [dataService] 请求数据字段检查:')
    console.log('  - name:', agentData.name, '(长度:', agentData.name.length, ')')
    console.log('  - description:', agentData.description, '(长度:', agentData.description.length, ')')
    console.log('  - author:', agentData.author, '(长度:', agentData.author.length, ')')
    console.log('  - version:', agentData.version, '(长度:', agentData.version.length, ')')
    console.log('  - category:', agentData.category)
    console.log('  - shareUrl:', agentData.shareUrl, '(长度:', agentData.shareUrl.length, ')')
    console.log('  - tags:', agentData.tags, '(数组长度:', agentData.tags.length, ')')
    console.log('  - usage:', agentData.usage, '(长度:', agentData.usage.length, ')')
    console.log('  - config:', agentData.config)

    console.log('🚀 [dataService] 发送POST请求到 /agents')
    // 发送请求
    const response = await apiClient.post<ApiResponse<Agent>>('/agents', agentData)
    
    console.log('✅ [dataService] 服务器响应成功:', response.data)
    
    return {
      success: true,
      data: response.data.data,
      message: '智能体添加成功'
    }
  } catch (error: any) {
    console.error('❌ [dataService] 添加智能体失败:', error)
    
    if (error.response) {
      console.error('❌ [dataService] HTTP错误响应:')
      console.error('  - 状态码:', error.response.status)
      console.error('  - 响应头:', error.response.headers)
      console.error('  - 响应数据:', error.response.data)
    }
    
    // 处理不同类型的错误
    if (error.response?.data?.error) {
      throw new Error(error.response.data.error)
    } else if (error.message) {
      throw new Error(error.message)
    } else {
      throw new Error('添加智能体时发生未知错误')
    }
  }
}

/**
 * 更新智能体
 * @param id 智能体ID
 * @param updateData 要更新的数据
 * @returns 返回更新后的智能体数据和操作结果的Promise
 */
export async function updateAgent(id: string, updateData: Partial<Agent>): Promise<AgentOperationResult> {
  try {
    console.log('🔧 [dataService] 开始处理updateAgent请求')
    console.log('🔧 [dataService] 智能体ID:', id)
    console.log('🔧 [dataService] 更新数据:', JSON.stringify(updateData, null, 2))
    
    // 客户端基础验证
    if (!id?.trim()) {
      throw new Error('智能体ID不能为空')
    }
    
    // 构造请求数据，过滤掉不需要的字段
    const { id: _, createdAt, updatedAt, ...requestData } = updateData
    
    console.log('📦 [dataService] 构造的请求数据:', JSON.stringify(requestData, null, 2))
    console.log('🚀 [dataService] 发送PUT请求到 /agents/' + id)
    
    // 发送请求
    const response = await apiClient.put<ApiResponse<Agent>>(`/agents/${id}`, requestData)
    
    console.log('✅ [dataService] 服务器响应成功:', response.data)
    
    return {
      success: true,
      data: response.data.data,
      message: '智能体更新成功'
    }
  } catch (error: any) {
    console.error('❌ [dataService] 更新智能体失败:', error)
    
    if (error.response) {
      console.error('❌ [dataService] HTTP错误响应:')
      console.error('  - 状态码:', error.response.status)
      console.error('  - 响应头:', error.response.headers)
      console.error('  - 响应数据:', error.response.data)
    }
    
    // 处理不同类型的错误
    if (error.response?.data?.error) {
      throw new Error(error.response.data.error)
    } else if (error.message) {
      throw new Error(error.message)
    } else {
      throw new Error('更新智能体时发生未知错误')
    }
  }
}

/**
 * 删除智能体
 * @param id 智能体ID
 * @returns 返回操作结果的Promise
 */
export async function deleteAgent(id: string): Promise<AgentOperationResult> {
  try {
    if (!id?.trim()) {
      return { success: false, error: '智能体ID不能为空' }
    }
    
    const response = await apiClient.delete<ApiResponse>(`/agents/${id}`)
    
    if (response.data.success) {
      return { success: true }
    } else {
      return { success: false, error: response.data.error || '删除智能体失败' }
    }
  } catch (error: any) {
    const errorMessage = error.response?.data?.error || error.message || '删除智能体失败'
    console.error('删除智能体失败:', error)
    return { success: false, error: errorMessage }
  }
}

/**
 * 根据ID获取智能体
 * @param id 智能体ID
 * @returns 返回智能体数据或null的Promise
 */
export async function getAgentById(id: string): Promise<Agent | null> {
  try {
    const response = await apiClient.get<ApiResponse<Agent>>(`/agents/${id}`)
    if (response.data.success && response.data.data) {
      return response.data.data
    }
    return null
  } catch (error) {
    console.error('获取智能体失败:', error)
    return null
  }
}

/**
 * 清空所有智能体数据
 * @returns 返回操作结果的Promise
 */
export async function clearAllAgents(): Promise<AgentOperationResult> {
  try {
    const response = await apiClient.delete<ApiResponse>('/agents')
    
    if (response.data.success) {
      return { success: true }
    } else {
      return { success: false, error: response.data.error || '清空数据失败' }
    }
  } catch (error: any) {
    const errorMessage = error.response?.data?.error || error.message || '清空数据失败'
    console.error('清空智能体数据失败:', error)
    return { success: false, error: errorMessage }
  }
}

/**
 * 导出智能体数据为JSON字符串
 * @returns 返回JSON格式的数据字符串的Promise
 */
export async function exportAgentsData(): Promise<string> {
  try {
    const response = await apiClient.get<ApiResponse<{ data: string }>>('/agents/export')
    if (response.data.success && response.data.data) {
      return response.data.data.data
    }
    throw new Error(response.data.error || '导出数据失败')
  } catch (error: any) {
    console.error('导出智能体数据失败:', error)
    throw error
  }
}

/**
 * 从JSON字符串导入智能体数据
 * @param jsonData JSON格式的数据字符串
 * @returns 返回操作结果的Promise
 */
export async function importAgentsData(jsonData: string): Promise<AgentOperationResult> {
  try {
    // 客户端基础验证
    const data: AgentData = JSON.parse(jsonData)
    
    if (!data.agents || !Array.isArray(data.agents)) {
      return { success: false, error: '数据格式不正确' }
    }
    
    // 验证每个智能体数据的完整性
    for (const agent of data.agents) {
      if (!agent.name || !agent.shareUrl) {
        return { success: false, error: '智能体数据不完整' }
      }
    }
    
    const response = await apiClient.post<ApiResponse>('/agents/import', { data: jsonData })
    
    if (response.data.success) {
      return { success: true }
    } else {
      return { success: false, error: response.data.error || '导入数据失败' }
    }
  } catch (error: any) {
    if (error instanceof SyntaxError) {
      return { success: false, error: 'JSON格式不正确' }
    }
    const errorMessage = error.response?.data?.error || error.message || '导入数据失败'
    console.error('导入智能体数据失败:', error)
    return { success: false, error: errorMessage }
  }
}

/**
 * 获取备份列表
 * @returns 返回备份信息列表的Promise
 */
export async function getBackupList(): Promise<BackupInfo[]> {
  try {
    const response = await apiClient.get<ApiResponse<BackupInfo[]>>('/backups')
    if (response.data.success && response.data.data) {
      return response.data.data
    }
    return []
  } catch (error) {
    console.error('获取备份列表失败:', error)
    return []
  }
}

/**
 * 创建数据备份
 * @returns 返回操作结果的Promise
 */
export async function createBackup(): Promise<AgentOperationResult<BackupInfo>> {
  try {
    const response = await apiClient.post<ApiResponse<BackupInfo>>('/backups')
    
    if (response.data.success) {
      return { success: true, data: response.data.data }
    } else {
      return { success: false, error: response.data.error || '创建备份失败' }
    }
  } catch (error: any) {
    const errorMessage = error.response?.data?.error || error.message || '创建备份失败'
    console.error('创建备份失败:', error)
    return { success: false, error: errorMessage }
  }
}

/**
 * 恢复数据备份
 * @param backupId 备份ID
 * @returns 返回操作结果的Promise
 */
export async function restoreBackup(backupId: string): Promise<AgentOperationResult> {
  try {
    const response = await apiClient.post<ApiResponse>(`/backups/${backupId}/restore`)
    
    if (response.data.success) {
      return { success: true }
    } else {
      return { success: false, error: response.data.error || '恢复备份失败' }
    }
  } catch (error: any) {
    const errorMessage = error.response?.data?.error || error.message || '恢复备份失败'
    console.error('恢复备份失败:', error)
    return { success: false, error: errorMessage }
  }
}